/*
 * Copyright (c) 2007, 2015, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */
/*
 * Copyright 2001-2005 The Apache Software Foundation.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
/*
 * $Id: SingleNodeCounter.java,v 1.2.4.1 2005/09/12 11:58:23 pvedula Exp $
 */

package com.sun.org.apache.xalan.internal.xsltc.dom;

import com.sun.org.apache.xalan.internal.xsltc.DOM;
import com.sun.org.apache.xalan.internal.xsltc.Translet;
import com.sun.org.apache.xml.internal.dtm.DTMAxisIterator;
import com.sun.org.apache.xml.internal.dtm.Axis;


/**
 * @author Jacek Ambroziak
 * @author Santiago Pericas-Geertsen
 */
public abstract class SingleNodeCounter extends NodeCounter {

  static private final int[] EmptyArray = new int[]{};
  DTMAxisIterator _countSiblings = null;

  public SingleNodeCounter(Translet translet,
      DOM document,
      DTMAxisIterator iterator) {
    super(translet, document, iterator);
  }

  public SingleNodeCounter(Translet translet,
      DOM document,
      DTMAxisIterator iterator,
      boolean hasFrom) {
    super(translet, document, iterator, hasFrom);
  }

  public NodeCounter setStartNode(int node) {
    _node = node;
    _nodeType = _document.getExpandedTypeID(node);
    _countSiblings = _document.getAxisIterator(Axis.PRECEDINGSIBLING);
    return this;
  }

  public String getCounter() {
    int result;
    if (_value != Integer.MIN_VALUE) {
      //See Errata E24
      if (_value == 0) {
        return "0";
      } else if (Double.isNaN(_value)) {
        return "NaN";
      } else if (_value < 0 && Double.isInfinite(_value)) {
        return "-Infinity";
      } else if (Double.isInfinite(_value)) {
        return "Infinity";
      } else {
        result = (int) _value;
      }
    } else {
      int next = _node;
      result = 0;
      boolean matchesCount = matchesCount(next);

      if (!matchesCount) {
        while ((next = _document.getParent(next)) > END) {
          if (matchesCount(next)) {
            break;          // found target
          }
          if (matchesFrom(next)) {
            next = END;
            break;          // no target found
          }
        }
      }

      if (next != END) {
        int from = next;

        if (!matchesCount && _hasFrom) {
          // Target found, but need to check if ancestor matches from
          while ((from = _document.getParent(from)) > END) {
            if (matchesFrom(from)) {
              break;          // found from
            }
          }
        }

        // Have we found ancestor matching from?
        if (from != END) {
          _countSiblings.setStartNode(next);
          do {
            if (matchesCount(next)) {
              result++;
            }
          } while ((next = _countSiblings.next()) != END);

          return formatNumbers(result);
        }
      }

      // If no target found then pass the empty list
      return formatNumbers(EmptyArray);
    }
    return formatNumbers(result);
  }

  public static NodeCounter getDefaultNodeCounter(Translet translet,
      DOM document,
      DTMAxisIterator iterator) {
    return new DefaultSingleNodeCounter(translet, document, iterator);
  }

  static class DefaultSingleNodeCounter extends SingleNodeCounter {

    public DefaultSingleNodeCounter(Translet translet,
        DOM document, DTMAxisIterator iterator) {
      super(translet, document, iterator);
    }

    public NodeCounter setStartNode(int node) {
      _node = node;
      _nodeType = _document.getExpandedTypeID(node);
      _countSiblings =
          _document.getTypedAxisIterator(Axis.PRECEDINGSIBLING,
              _document.getExpandedTypeID(node));
      return this;
    }

    public String getCounter() {
      int result;
      if (_value != Integer.MIN_VALUE) {
        //See Errata E24
        if (_value == 0) {
          return "0";
        } else if (Double.isNaN(_value)) {
          return "NaN";
        } else if (_value < 0 && Double.isInfinite(_value)) {
          return "-Infinity";
        } else if (Double.isInfinite(_value)) {
          return "Infinity";
        } else {
          result = (int) _value;
        }
      } else {
        int next;
        result = 1;
        _countSiblings.setStartNode(_node);
        while ((next = _countSiblings.next()) != END) {
          result++;
        }
      }
      return formatNumbers(result);
    }
  }
}
